stringify-object

What is stringify-object?

The stringify-object npm package is used to stringify an object into a string format that is more readable than JSON.stringify, especially for multi-line strings and functions. It provides options to customize the output, such as indentation, single quotes, and filtering of object properties.

What are stringify-object's main functionalities?

Stringify an object with custom indentation

This feature allows you to convert an object to a string with a specified indentation for better readability. The code sample demonstrates how to use a two-space indentation.

const stringifyObject = require('stringify-object');
const obj = {foo: 'bar', 'arr': [1, 2, 3]};
console.log(stringifyObject(obj, {
    indent: '  '
}));

Stringify an object using single quotes

This feature allows you to stringify an object using single quotes instead of double quotes for string values. The code sample shows how to enable this option.

const stringifyObject = require('stringify-object');
const obj = {foo: 'bar'};
console.log(stringifyObject(obj, {
    singleQuotes: true
}));

Filter properties during stringification

This feature allows you to filter out properties from the resulting string based on a custom function. The code sample demonstrates excluding the 'baz' property from the stringified output.

const stringifyObject = require('stringify-object');
const obj = {foo: 'bar', baz: 'qux'};
console.log(stringifyObject(obj, {
    filter: (obj, prop, value) => prop !== 'baz'
}));

Other packages similar to stringify-object

json-stringify-pretty-compact

This package offers a way to stringify JSON data in a pretty (indented) yet compact (no unnecessary whitespace) form. It is similar to stringify-object but focuses on compactness and does not handle functions or undefined values.

pretty-format

Developed by Facebook as part of the Jest testing framework, pretty-format allows serialization of JavaScript objects into a string with pretty printing. It supports plugins and can handle React elements, which makes it more versatile than stringify-object for certain use cases.

flatted

Flatted is a package that can stringify and parse objects with circular references, which JSON.stringify cannot handle. It is similar to stringify-object in that it provides a way to represent objects as strings, but it is specifically designed to work with circular data structures.

README

stringify-object

Stringify an object/array like JSON.stringify just without all the double-quotes

Useful for when you want to get the string representation of an object in a formatted way.

It also handles circular references and lets you specify quote type.

Install

$ npm install stringify-object

Usage

const stringifyObject = require('stringify-object');

const obj = {
	foo: 'bar',
	'arr': [1, 2, 3],
	nested: { hello: "world" }
};

const pretty = stringifyObject(obj, {
	indent: '  ',
	singleQuotes: false
});

console.log(pretty);
/*
{
	foo: "bar",
	arr: [
		1,
		2,
		3
	],
	nested: {
		hello: "world"
	}
}
*/

API

stringifyObject(input, [options])

Circular references will be replaced with "[Circular]".

input

Type: Object Array

options

indent

Type: string
Default: \t

Preferred indentation.

singleQuotes

Type: boolean
Default: true

Set to false to get double-quoted strings.

filter(obj, prop)

Type: Function

Expected to return a boolean of whether to include the property prop of the object obj in the output.

transform(obj, prop, originalResult)

Type: Function
Default: undefined

Expected to return a string that transforms the string that resulted from stringifying obj[prop]. This can be used to detect special types of objects that need to be stringified in a particular way. The transform function might return an alternate string in this case, otherwise returning the originalResult.

Here's an example that uses the transform option to mask fields named "password":

const obj = {
	user: 'becky',
	password: 'secret'
}

const pretty = stringifyObject(obj, {
	transform: (obj, prop, originalResult) => {
		if (prop === 'password') {
			return originalResult.replace(/\w/g, '*');
		} else {
			return originalResult;
		}
	}
});

console.log(pretty);
/*
{
	user: 'becky',
	password: '******'
}
*/

inlineCharacterLimit

Type: number

When set, will inline values up to inlineCharacterLimit length for the sake of more terse output.

For example, given the example at the top of the README:

const obj = {
	foo: 'bar',
	'arr': [1, 2, 3],
	nested: { hello: "world" }
};

const pretty = stringifyObject(obj, {
	indent: '  ',
	singleQuotes: false,
	inlineCharacterLimit: 12
});

console.log(pretty);
/*
{
	foo: "bar",
	arr: [1, 2, 3],
	nested: {
		hello: "world"
	}
}
*/

As you can see, arr was printed as a one-liner because its string was shorter than 12 characters.

License

BSD-2-Clause © Yeoman team